#ifndef _WX_DOCH__
#define _WX_DOCH__

#include "wx/defs.h"

#if wxUSE_DOC_VIEW_ARCHITECTURE

#include "wx/list.h"
#include "wx/string.h"
#include "wx/frame.h"

#if wxUSE_PRINTING_ARCHITECTURE
#include "wx/print.h"
#endif

class wxWindow;
class wxDocument;
class wxView;
class wxDocTemplate;
class wxDocManager;
class wxPrintInfo;
class wxCommandProcessor;
class wxFileHistory;
class wxConfigBase;

#include "wx/stream.h"

enum {
  wxDOC_SDI = 1,
  wxDOC_MDI,
  wxDOC_NEW,
  wxDOC_SILENT,
  wxDEFAULT_DOCMAN_FLAGS = wxDOC_SDI
};


enum {
  wxTEMPLATE_VISIBLE = 1,
  wxTEMPLATE_INVISIBLE,
  wxDEFAULT_TEMPLATE_FLAGS = wxTEMPLATE_VISIBLE
};

#define wxMAX_FILE_HISTORY 9

class wxDocument : public wxEvtHandler {
  public:
    wxDocument( wxDocument *parent = ( wxDocument * ) NULL );
    virtual ~wxDocument();


    void SetFilename( const wxString& filename, bool notifyViews = false );
    wxString GetFilename() const { return m_documentFile; }

    void SetTitle( const wxString& title ) { m_documentTitle = title; }
    wxString GetTitle() const { return m_documentTitle; }

    void SetDocumentName( const wxString& name ) { m_documentTypeName = name; }
    wxString GetDocumentName() const { return m_documentTypeName; }

    bool GetDocumentSaved() const { return m_savedYet; }
    void SetDocumentSaved( bool saved = true ) { m_savedYet = saved; }

    virtual bool Close();
    virtual bool Save();
    virtual bool SaveAs();
    virtual bool Revert();

    virtual wxOutputStream& SaveObject( wxOutputStream& stream );
    virtual wxInputStream& LoadObject( wxInputStream& stream );
    virtual bool OnSaveDocument( const wxString& filename );
    virtual bool OnOpenDocument( const wxString& filename );
    virtual bool OnNewDocument();
    virtual bool OnCloseDocument();
    virtual bool OnSaveModified();
    virtual bool OnCreate( const wxString& path, long flags );
    virtual wxCommandProcessor *OnCreateCommandProcessor();
    virtual wxCommandProcessor *GetCommandProcessor() const { return m_commandProcessor; }
    virtual void SetCommandProcessor( wxCommandProcessor *proc ) { m_commandProcessor = proc; }
    virtual void OnChangedViewList();

    virtual bool DeleteContents();

    virtual bool Draw( wxDC& );
    virtual bool IsModified() const { return m_documentModified; }
    virtual void Modify( bool mod ) { m_documentModified = mod; }

    virtual bool AddView( wxView *view );
    virtual bool RemoveView( wxView *view );
    wxList& GetViews() { return m_documentViews; }
    const wxList& GetViews() const { return m_documentViews; }
    wxView *GetFirstView() const;

    virtual void UpdateAllViews( wxView *sender = ( wxView * ) NULL, wxObject *hint = ( wxObject * ) NULL );
    virtual void NotifyClosing();
    virtual bool DeleteAllViews();
    virtual wxDocManager *GetDocumentManager() const;
    virtual wxDocTemplate *GetDocumentTemplate() const { return m_documentTemplate; }
    virtual void SetDocumentTemplate( wxDocTemplate *temp ) { m_documentTemplate = temp; }
    virtual bool GetPrintableName( wxString& buf ) const;
    wxString GetUserReadableName() const {
      wxString s;
      GetPrintableName( s );
      return s;
    }
    virtual wxWindow *GetDocumentWindow() const;

  protected:
    wxList                m_documentViews;
    wxString              m_documentFile;
    wxString              m_documentTitle;
    wxString              m_documentTypeName;
    wxDocTemplate*        m_documentTemplate;
    bool                  m_documentModified;
    wxDocument*           m_documentParent;
    wxCommandProcessor*   m_commandProcessor;
    bool                  m_savedYet;




    virtual bool DoSaveDocument( const wxString& file );
    virtual bool DoOpenDocument( const wxString& file );

  private:
    DECLARE_ABSTRACT_CLASS( wxDocument )
    DECLARE_NO_COPY_CLASS( wxDocument )
};

class wxView: public wxEvtHandler {
  public:

    wxView();
    virtual ~wxView();

    wxDocument *GetDocument() const { return m_viewDocument; }
    virtual void SetDocument( wxDocument *doc );

    wxString GetViewName() const { return m_viewTypeName; }
    void SetViewName( const wxString& name ) { m_viewTypeName = name; }

    wxWindow *GetFrame() const { return m_viewFrame ; }
    void SetFrame( wxWindow *frame ) { m_viewFrame = frame; }

    virtual void OnActivateView( bool activate, wxView *activeView, wxView *deactiveView );
    virtual void OnDraw( wxDC *dc ) = 0;
    virtual void OnPrint( wxDC *dc, wxObject *info );
    virtual void OnUpdate( wxView *sender, wxObject *hint = ( wxObject * ) NULL );
    virtual void OnClosingDocument() {}
    virtual void OnChangeFilename();



    virtual bool OnCreate( wxDocument * ( doc ), long ( flags ) ) { return true; }




    virtual bool Close( bool deleteWindow = true );


    virtual bool OnClose( bool deleteWindow );


    virtual bool ProcessEvent( wxEvent& event );



    virtual void Activate( bool activate );

    wxDocManager *GetDocumentManager() const
    { return m_viewDocument->GetDocumentManager(); }

    #if wxUSE_PRINTING_ARCHITECTURE
    virtual wxPrintout *OnCreatePrintout();
    #endif

  protected:
    wxDocument*       m_viewDocument;
    wxString          m_viewTypeName;
    wxWindow*         m_viewFrame;

  private:
    DECLARE_ABSTRACT_CLASS( wxView )
    DECLARE_NO_COPY_CLASS( wxView )
};


class wxDocTemplate: public wxObject {

    friend class wxDocManager;

  public:


    wxDocTemplate( wxDocManager *manager,
                   const wxString& descr,
                   const wxString& filter,
                   const wxString& dir,
                   const wxString& ext,
                   const wxString& docTypeName,
                   const wxString& viewTypeName,
                   wxClassInfo *docClassInfo = ( wxClassInfo * ) NULL,
                   wxClassInfo *viewClassInfo = ( wxClassInfo * )NULL,
                   long flags = wxDEFAULT_TEMPLATE_FLAGS );

    virtual ~wxDocTemplate();




    virtual wxDocument *CreateDocument( const wxString& path, long flags = 0 );
    virtual wxView *CreateView( wxDocument *doc, long flags = 0 );



    virtual bool InitDocument( wxDocument* doc, const wxString& path, long flags = 0 );

    wxString GetDefaultExtension() const { return m_defaultExt; }
    wxString GetDescription() const { return m_description; }
    wxString GetDirectory() const { return m_directory; }
    wxDocManager *GetDocumentManager() const { return m_documentManager; }
    void SetDocumentManager( wxDocManager *manager ) { m_documentManager = manager; }
    wxString GetFileFilter() const { return m_fileFilter; }
    long GetFlags() const { return m_flags; }
    virtual wxString GetViewName() const { return m_viewTypeName; }
    virtual wxString GetDocumentName() const { return m_docTypeName; }

    void SetFileFilter( const wxString& filter ) { m_fileFilter = filter; }
    void SetDirectory( const wxString& dir ) { m_directory = dir; }
    void SetDescription( const wxString& descr ) { m_description = descr; }
    void SetDefaultExtension( const wxString& ext ) { m_defaultExt = ext; }
    void SetFlags( long flags ) { m_flags = flags; }

    bool IsVisible() const { return ( ( m_flags & wxTEMPLATE_VISIBLE ) == wxTEMPLATE_VISIBLE ); }

    wxClassInfo* GetDocClassInfo() const { return m_docClassInfo; }
    wxClassInfo* GetViewClassInfo() const { return m_viewClassInfo; }

    virtual bool FileMatchesTemplate( const wxString& path );

  protected:
    long              m_flags;
    wxString          m_fileFilter;
    wxString          m_directory;
    wxString          m_description;
    wxString          m_defaultExt;
    wxString          m_docTypeName;
    wxString          m_viewTypeName;
    wxDocManager*     m_documentManager;


    wxClassInfo*      m_docClassInfo;
    wxClassInfo*      m_viewClassInfo;




    virtual wxDocument *DoCreateDocument();
    virtual wxView *DoCreateView();

  private:
    DECLARE_CLASS( wxDocTemplate )
    DECLARE_NO_COPY_CLASS( wxDocTemplate )
};



class wxDocManager: public wxEvtHandler {
  public:
    wxDocManager( long flags = wxDEFAULT_DOCMAN_FLAGS, bool initialize = true );
    virtual ~wxDocManager();

    virtual bool Initialize();


    void OnFileClose( wxCommandEvent& event );
    void OnFileCloseAll( wxCommandEvent& event );
    void OnFileNew( wxCommandEvent& event );
    void OnFileOpen( wxCommandEvent& event );
    void OnFileRevert( wxCommandEvent& event );
    void OnFileSave( wxCommandEvent& event );
    void OnFileSaveAs( wxCommandEvent& event );
    void OnPrint( wxCommandEvent& event );
    void OnPreview( wxCommandEvent& event );
    void OnUndo( wxCommandEvent& event );
    void OnRedo( wxCommandEvent& event );


    void OnUpdateFileOpen( wxUpdateUIEvent& event );
    void OnUpdateFileClose( wxUpdateUIEvent& event );
    void OnUpdateFileRevert( wxUpdateUIEvent& event );
    void OnUpdateFileNew( wxUpdateUIEvent& event );
    void OnUpdateFileSave( wxUpdateUIEvent& event );
    void OnUpdateFileSaveAs( wxUpdateUIEvent& event );
    void OnUpdateUndo( wxUpdateUIEvent& event );
    void OnUpdateRedo( wxUpdateUIEvent& event );

    void OnUpdatePrint( wxUpdateUIEvent& event );
    void OnUpdatePreview( wxUpdateUIEvent& event );


    virtual bool ProcessEvent( wxEvent& event );



    virtual void OnOpenFileFailure() { }

    virtual wxDocument *CreateDocument( const wxString& path, long flags = 0 );
    virtual wxView *CreateView( wxDocument *doc, long flags = 0 );
    virtual void DeleteTemplate( wxDocTemplate *temp, long flags = 0 );
    virtual bool FlushDoc( wxDocument *doc );
    virtual wxDocTemplate *MatchTemplate( const wxString& path );
    virtual wxDocTemplate *SelectDocumentPath( wxDocTemplate **templates,
        int noTemplates, wxString& path, long flags, bool save = false );
    virtual wxDocTemplate *SelectDocumentType( wxDocTemplate **templates,
        int noTemplates, bool sort = false );
    virtual wxDocTemplate *SelectViewType( wxDocTemplate **templates,
                                           int noTemplates, bool sort = false );
    virtual wxDocTemplate *FindTemplateForPath( const wxString& path );

    void AssociateTemplate( wxDocTemplate *temp );
    void DisassociateTemplate( wxDocTemplate *temp );

    wxDocument *GetCurrentDocument() const;

    void SetMaxDocsOpen( int n ) { m_maxDocsOpen = n; }
    int GetMaxDocsOpen() const { return m_maxDocsOpen; }


    void AddDocument( wxDocument *doc );
    void RemoveDocument( wxDocument *doc );
    bool CloseDocuments( bool force = true );
    bool CloseDocument( wxDocument* doc, bool force = false );


    bool Clear( bool force = true );



    virtual void ActivateView( wxView *view, bool activate = true );
    virtual wxView *GetCurrentView() const;

    wxList& GetDocuments() { return m_docs; }
    wxList& GetTemplates() { return m_templates; }
    virtual bool MakeDefaultName( wxString& buf );
    wxString MakeNewDocumentName() const {
      wxString s;
      wx_const_cast( wxDocManager *, this )->MakeDefaultName( s );
      return s;
    }

    virtual wxString MakeFrameTitle( wxDocument* doc );

    virtual wxFileHistory *OnCreateFileHistory();
    virtual wxFileHistory *GetFileHistory() const { return m_fileHistory; }
    virtual void AddFileToHistory( const wxString& file );
    virtual void RemoveFileFromHistory( size_t i );
    virtual size_t GetHistoryFilesCount() const;
    virtual wxString GetHistoryFile( size_t i ) const;
    virtual void FileHistoryUseMenu( wxMenu *menu );
    virtual void FileHistoryRemoveMenu( wxMenu *menu );
    #if wxUSE_CONFIG
    virtual void FileHistoryLoad( wxConfigBase& config );
    virtual void FileHistorySave( wxConfigBase& config );
    #endif

    virtual void FileHistoryAddFilesToMenu();
    virtual void FileHistoryAddFilesToMenu( wxMenu* menu );

    wxString GetLastDirectory() const { return m_lastDirectory; }
    void SetLastDirectory( const wxString& dir ) { m_lastDirectory = dir; }


    static wxDocManager* GetDocumentManager() { return sm_docManager; }
    wxDEPRECATED( size_t GetNoHistoryFiles() const );
  protected:
    long              m_flags;
    int               m_defaultDocumentNameCounter;
    int               m_maxDocsOpen;
    wxList            m_docs;
    wxList            m_templates;
    wxView*           m_currentView;
    wxFileHistory*    m_fileHistory;
    wxString          m_lastDirectory;
    static wxDocManager* sm_docManager;

    DECLARE_EVENT_TABLE()
    DECLARE_DYNAMIC_CLASS( wxDocManager )
    DECLARE_NO_COPY_CLASS( wxDocManager )
};

inline size_t wxDocManager::GetNoHistoryFiles() const {
  return GetHistoryFilesCount();
}

class wxDocChildFrame : public wxFrame {
  public:
    wxDocChildFrame( wxDocument *doc,
                     wxView *view,
                     wxFrame *frame,
                     wxWindowID id,
                     const wxString& title,
                     const wxPoint& pos = wxDefaultPosition,
                     const wxSize& size = wxDefaultSize,
                     long type = wxDEFAULT_FRAME_STYLE,
                     const wxString& name = wxT( "frame" ) );
    virtual ~wxDocChildFrame() {}


    virtual bool ProcessEvent( wxEvent& event );

    void OnActivate( wxActivateEvent& event );
    void OnCloseWindow( wxCloseEvent& event );

    wxDocument *GetDocument() const { return m_childDocument; }
    wxView *GetView() const { return m_childView; }
    void SetDocument( wxDocument *doc ) { m_childDocument = doc; }
    void SetView( wxView *view ) { m_childView = view; }
    bool Destroy() { m_childView = ( wxView * )NULL; return wxFrame::Destroy(); }

  protected:
    wxDocument*       m_childDocument;
    wxView*           m_childView;

  private:
    DECLARE_CLASS( wxDocChildFrame )
    DECLARE_EVENT_TABLE()
    DECLARE_NO_COPY_CLASS( wxDocChildFrame )
};

class wxDocParentFrame : public wxFrame {
  public:
    wxDocParentFrame();
    wxDocParentFrame( wxDocManager *manager,
                      wxFrame *frame,
                      wxWindowID id,
                      const wxString& title,
                      const wxPoint& pos = wxDefaultPosition,
                      const wxSize& size = wxDefaultSize,
                      long style = wxDEFAULT_FRAME_STYLE,
                      const wxString& name = wxFrameNameStr );

    bool Create( wxDocManager *manager,
                 wxFrame *frame,
                 wxWindowID id,
                 const wxString& title,
                 const wxPoint& pos = wxDefaultPosition,
                 const wxSize& size = wxDefaultSize,
                 long style = wxDEFAULT_FRAME_STYLE,
                 const wxString& name = wxFrameNameStr );


    virtual bool ProcessEvent( wxEvent& event );

    wxDocManager *GetDocumentManager() const { return m_docManager; }

    void OnExit( wxCommandEvent& event );
    void OnMRUFile( wxCommandEvent& event );
    void OnCloseWindow( wxCloseEvent& event );

  protected:
    wxDocManager *m_docManager;

  private:
    typedef wxFrame base_type;
    DECLARE_CLASS( wxDocParentFrame )
    DECLARE_EVENT_TABLE()
    DECLARE_NO_COPY_CLASS( wxDocParentFrame )
};

#if wxUSE_PRINTING_ARCHITECTURE
class wxDocPrintout : public wxPrintout {
  public:
    wxDocPrintout( wxView *view = ( wxView * ) NULL, const wxString& title = wxT( "Printout" ) );
    bool OnPrintPage( int page );
    bool HasPage( int page );
    bool OnBeginDocument( int startPage, int endPage );
    void GetPageInfo( int *minPage, int *maxPage, int *selPageFrom, int *selPageTo );

    virtual wxView *GetView() { return m_printoutView; }

  protected:
    wxView*       m_printoutView;

  private:
    DECLARE_DYNAMIC_CLASS( wxDocPrintout )
    DECLARE_NO_COPY_CLASS( wxDocPrintout )
};
#endif

class wxFileHistory : public wxObject {
  public:
    wxFileHistory( size_t maxFiles = 9, wxWindowID idBase = wxID_FILE1 );
    virtual ~wxFileHistory();


    virtual void AddFileToHistory( const wxString& file );
    virtual void RemoveFileFromHistory( size_t i );
    virtual int GetMaxFiles() const { return ( int )m_fileMaxFiles; }
    virtual void UseMenu( wxMenu *menu );


    virtual void RemoveMenu( wxMenu *menu );

    #if wxUSE_CONFIG
    virtual void Load( wxConfigBase& config );
    virtual void Save( wxConfigBase& config );
    #endif

    virtual void AddFilesToMenu();
    virtual void AddFilesToMenu( wxMenu* menu );


    virtual wxString GetHistoryFile( size_t i ) const;
    virtual size_t GetCount() const { return m_fileHistoryN; }

    const wxList& GetMenus() const { return m_fileMenus; }
    void SetBaseId( wxWindowID baseId ) { m_idBase = baseId; }
    wxWindowID GetBaseId() const { return m_idBase; }
    wxDEPRECATED( size_t GetNoHistoryFiles() const );

  protected:

    wxChar**          m_fileHistory;

    size_t            m_fileHistoryN;

    wxList            m_fileMenus;

    size_t            m_fileMaxFiles;

  private:

    wxWindowID m_idBase;

    DECLARE_DYNAMIC_CLASS( wxFileHistory )
    DECLARE_NO_COPY_CLASS( wxFileHistory )
};

inline size_t wxFileHistory::GetNoHistoryFiles() const {
  return m_fileHistoryN;
}

bool wxTransferFileToStream( const wxString& filename, wxOutputStream& stream );
bool wxTransferStreamToFile( wxInputStream& stream, const wxString& filename );

#endif

#endif
